package com.sunny.fetch.pojo;

import java.util.ArrayList;
import java.util.List;

public class FExpressExample {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    public FExpressExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andTidIsNull() {
            addCriterion("tid is null");
            return (Criteria) this;
        }

        public Criteria andTidIsNotNull() {
            addCriterion("tid is not null");
            return (Criteria) this;
        }

        public Criteria andTidEqualTo(Long value) {
            addCriterion("tid =", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidNotEqualTo(Long value) {
            addCriterion("tid <>", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidGreaterThan(Long value) {
            addCriterion("tid >", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidGreaterThanOrEqualTo(Long value) {
            addCriterion("tid >=", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidLessThan(Long value) {
            addCriterion("tid <", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidLessThanOrEqualTo(Long value) {
            addCriterion("tid <=", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidIn(List<Long> values) {
            addCriterion("tid in", values, "tid");
            return (Criteria) this;
        }

        public Criteria andTidNotIn(List<Long> values) {
            addCriterion("tid not in", values, "tid");
            return (Criteria) this;
        }

        public Criteria andTidBetween(Long value1, Long value2) {
            addCriterion("tid between", value1, value2, "tid");
            return (Criteria) this;
        }

        public Criteria andTidNotBetween(Long value1, Long value2) {
            addCriterion("tid not between", value1, value2, "tid");
            return (Criteria) this;
        }

        public Criteria andTsCodeIsNull() {
            addCriterion("ts_code is null");
            return (Criteria) this;
        }

        public Criteria andTsCodeIsNotNull() {
            addCriterion("ts_code is not null");
            return (Criteria) this;
        }

        public Criteria andTsCodeEqualTo(String value) {
            addCriterion("ts_code =", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeNotEqualTo(String value) {
            addCriterion("ts_code <>", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeGreaterThan(String value) {
            addCriterion("ts_code >", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeGreaterThanOrEqualTo(String value) {
            addCriterion("ts_code >=", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeLessThan(String value) {
            addCriterion("ts_code <", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeLessThanOrEqualTo(String value) {
            addCriterion("ts_code <=", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeLike(String value) {
            addCriterion("ts_code like", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeNotLike(String value) {
            addCriterion("ts_code not like", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeIn(List<String> values) {
            addCriterion("ts_code in", values, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeNotIn(List<String> values) {
            addCriterion("ts_code not in", values, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeBetween(String value1, String value2) {
            addCriterion("ts_code between", value1, value2, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeNotBetween(String value1, String value2) {
            addCriterion("ts_code not between", value1, value2, "tsCode");
            return (Criteria) this;
        }

        public Criteria andAnnDateIsNull() {
            addCriterion("ann_date is null");
            return (Criteria) this;
        }

        public Criteria andAnnDateIsNotNull() {
            addCriterion("ann_date is not null");
            return (Criteria) this;
        }

        public Criteria andAnnDateEqualTo(String value) {
            addCriterion("ann_date =", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateNotEqualTo(String value) {
            addCriterion("ann_date <>", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateGreaterThan(String value) {
            addCriterion("ann_date >", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateGreaterThanOrEqualTo(String value) {
            addCriterion("ann_date >=", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateLessThan(String value) {
            addCriterion("ann_date <", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateLessThanOrEqualTo(String value) {
            addCriterion("ann_date <=", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateLike(String value) {
            addCriterion("ann_date like", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateNotLike(String value) {
            addCriterion("ann_date not like", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateIn(List<String> values) {
            addCriterion("ann_date in", values, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateNotIn(List<String> values) {
            addCriterion("ann_date not in", values, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateBetween(String value1, String value2) {
            addCriterion("ann_date between", value1, value2, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateNotBetween(String value1, String value2) {
            addCriterion("ann_date not between", value1, value2, "annDate");
            return (Criteria) this;
        }

        public Criteria andEndDateIsNull() {
            addCriterion("end_date is null");
            return (Criteria) this;
        }

        public Criteria andEndDateIsNotNull() {
            addCriterion("end_date is not null");
            return (Criteria) this;
        }

        public Criteria andEndDateEqualTo(String value) {
            addCriterion("end_date =", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotEqualTo(String value) {
            addCriterion("end_date <>", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateGreaterThan(String value) {
            addCriterion("end_date >", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateGreaterThanOrEqualTo(String value) {
            addCriterion("end_date >=", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateLessThan(String value) {
            addCriterion("end_date <", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateLessThanOrEqualTo(String value) {
            addCriterion("end_date <=", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateLike(String value) {
            addCriterion("end_date like", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotLike(String value) {
            addCriterion("end_date not like", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateIn(List<String> values) {
            addCriterion("end_date in", values, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotIn(List<String> values) {
            addCriterion("end_date not in", values, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateBetween(String value1, String value2) {
            addCriterion("end_date between", value1, value2, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotBetween(String value1, String value2) {
            addCriterion("end_date not between", value1, value2, "endDate");
            return (Criteria) this;
        }

        public Criteria andRevenueIsNull() {
            addCriterion("revenue is null");
            return (Criteria) this;
        }

        public Criteria andRevenueIsNotNull() {
            addCriterion("revenue is not null");
            return (Criteria) this;
        }

        public Criteria andRevenueEqualTo(Float value) {
            addCriterion("revenue =", value, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueNotEqualTo(Float value) {
            addCriterion("revenue <>", value, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueGreaterThan(Float value) {
            addCriterion("revenue >", value, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueGreaterThanOrEqualTo(Float value) {
            addCriterion("revenue >=", value, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueLessThan(Float value) {
            addCriterion("revenue <", value, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueLessThanOrEqualTo(Float value) {
            addCriterion("revenue <=", value, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueIn(List<Float> values) {
            addCriterion("revenue in", values, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueNotIn(List<Float> values) {
            addCriterion("revenue not in", values, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueBetween(Float value1, Float value2) {
            addCriterion("revenue between", value1, value2, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueNotBetween(Float value1, Float value2) {
            addCriterion("revenue not between", value1, value2, "revenue");
            return (Criteria) this;
        }

        public Criteria andOperateProfitIsNull() {
            addCriterion("operate_profit is null");
            return (Criteria) this;
        }

        public Criteria andOperateProfitIsNotNull() {
            addCriterion("operate_profit is not null");
            return (Criteria) this;
        }

        public Criteria andOperateProfitEqualTo(Float value) {
            addCriterion("operate_profit =", value, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitNotEqualTo(Float value) {
            addCriterion("operate_profit <>", value, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitGreaterThan(Float value) {
            addCriterion("operate_profit >", value, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitGreaterThanOrEqualTo(Float value) {
            addCriterion("operate_profit >=", value, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitLessThan(Float value) {
            addCriterion("operate_profit <", value, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitLessThanOrEqualTo(Float value) {
            addCriterion("operate_profit <=", value, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitIn(List<Float> values) {
            addCriterion("operate_profit in", values, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitNotIn(List<Float> values) {
            addCriterion("operate_profit not in", values, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitBetween(Float value1, Float value2) {
            addCriterion("operate_profit between", value1, value2, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitNotBetween(Float value1, Float value2) {
            addCriterion("operate_profit not between", value1, value2, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitIsNull() {
            addCriterion("total_profit is null");
            return (Criteria) this;
        }

        public Criteria andTotalProfitIsNotNull() {
            addCriterion("total_profit is not null");
            return (Criteria) this;
        }

        public Criteria andTotalProfitEqualTo(Float value) {
            addCriterion("total_profit =", value, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitNotEqualTo(Float value) {
            addCriterion("total_profit <>", value, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitGreaterThan(Float value) {
            addCriterion("total_profit >", value, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitGreaterThanOrEqualTo(Float value) {
            addCriterion("total_profit >=", value, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitLessThan(Float value) {
            addCriterion("total_profit <", value, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitLessThanOrEqualTo(Float value) {
            addCriterion("total_profit <=", value, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitIn(List<Float> values) {
            addCriterion("total_profit in", values, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitNotIn(List<Float> values) {
            addCriterion("total_profit not in", values, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitBetween(Float value1, Float value2) {
            addCriterion("total_profit between", value1, value2, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitNotBetween(Float value1, Float value2) {
            addCriterion("total_profit not between", value1, value2, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andNIncomeIsNull() {
            addCriterion("n_income is null");
            return (Criteria) this;
        }

        public Criteria andNIncomeIsNotNull() {
            addCriterion("n_income is not null");
            return (Criteria) this;
        }

        public Criteria andNIncomeEqualTo(Float value) {
            addCriterion("n_income =", value, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeNotEqualTo(Float value) {
            addCriterion("n_income <>", value, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeGreaterThan(Float value) {
            addCriterion("n_income >", value, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("n_income >=", value, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeLessThan(Float value) {
            addCriterion("n_income <", value, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeLessThanOrEqualTo(Float value) {
            addCriterion("n_income <=", value, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeIn(List<Float> values) {
            addCriterion("n_income in", values, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeNotIn(List<Float> values) {
            addCriterion("n_income not in", values, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeBetween(Float value1, Float value2) {
            addCriterion("n_income between", value1, value2, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeNotBetween(Float value1, Float value2) {
            addCriterion("n_income not between", value1, value2, "nIncome");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsIsNull() {
            addCriterion("total_assets is null");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsIsNotNull() {
            addCriterion("total_assets is not null");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsEqualTo(Float value) {
            addCriterion("total_assets =", value, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsNotEqualTo(Float value) {
            addCriterion("total_assets <>", value, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsGreaterThan(Float value) {
            addCriterion("total_assets >", value, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("total_assets >=", value, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsLessThan(Float value) {
            addCriterion("total_assets <", value, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsLessThanOrEqualTo(Float value) {
            addCriterion("total_assets <=", value, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsIn(List<Float> values) {
            addCriterion("total_assets in", values, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsNotIn(List<Float> values) {
            addCriterion("total_assets not in", values, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsBetween(Float value1, Float value2) {
            addCriterion("total_assets between", value1, value2, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalAssetsNotBetween(Float value1, Float value2) {
            addCriterion("total_assets not between", value1, value2, "totalAssets");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntIsNull() {
            addCriterion("total_hldr_eqy_exc_min_int is null");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntIsNotNull() {
            addCriterion("total_hldr_eqy_exc_min_int is not null");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntEqualTo(Float value) {
            addCriterion("total_hldr_eqy_exc_min_int =", value, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntNotEqualTo(Float value) {
            addCriterion("total_hldr_eqy_exc_min_int <>", value, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntGreaterThan(Float value) {
            addCriterion("total_hldr_eqy_exc_min_int >", value, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntGreaterThanOrEqualTo(Float value) {
            addCriterion("total_hldr_eqy_exc_min_int >=", value, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntLessThan(Float value) {
            addCriterion("total_hldr_eqy_exc_min_int <", value, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntLessThanOrEqualTo(Float value) {
            addCriterion("total_hldr_eqy_exc_min_int <=", value, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntIn(List<Float> values) {
            addCriterion("total_hldr_eqy_exc_min_int in", values, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntNotIn(List<Float> values) {
            addCriterion("total_hldr_eqy_exc_min_int not in", values, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntBetween(Float value1, Float value2) {
            addCriterion("total_hldr_eqy_exc_min_int between", value1, value2, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andTotalHldrEqyExcMinIntNotBetween(Float value1, Float value2) {
            addCriterion("total_hldr_eqy_exc_min_int not between", value1, value2, "totalHldrEqyExcMinInt");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsIsNull() {
            addCriterion("diluted_eps is null");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsIsNotNull() {
            addCriterion("diluted_eps is not null");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsEqualTo(Float value) {
            addCriterion("diluted_eps =", value, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsNotEqualTo(Float value) {
            addCriterion("diluted_eps <>", value, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsGreaterThan(Float value) {
            addCriterion("diluted_eps >", value, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsGreaterThanOrEqualTo(Float value) {
            addCriterion("diluted_eps >=", value, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsLessThan(Float value) {
            addCriterion("diluted_eps <", value, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsLessThanOrEqualTo(Float value) {
            addCriterion("diluted_eps <=", value, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsIn(List<Float> values) {
            addCriterion("diluted_eps in", values, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsNotIn(List<Float> values) {
            addCriterion("diluted_eps not in", values, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsBetween(Float value1, Float value2) {
            addCriterion("diluted_eps between", value1, value2, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsNotBetween(Float value1, Float value2) {
            addCriterion("diluted_eps not between", value1, value2, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedRoeIsNull() {
            addCriterion("diluted_roe is null");
            return (Criteria) this;
        }

        public Criteria andDilutedRoeIsNotNull() {
            addCriterion("diluted_roe is not null");
            return (Criteria) this;
        }

        public Criteria andDilutedRoeEqualTo(Float value) {
            addCriterion("diluted_roe =", value, "dilutedRoe");
            return (Criteria) this;
        }

        public Criteria andDilutedRoeNotEqualTo(Float value) {
            addCriterion("diluted_roe <>", value, "dilutedRoe");
            return (Criteria) this;
        }

        public Criteria andDilutedRoeGreaterThan(Float value) {
            addCriterion("diluted_roe >", value, "dilutedRoe");
            return (Criteria) this;
        }

        public Criteria andDilutedRoeGreaterThanOrEqualTo(Float value) {
            addCriterion("diluted_roe >=", value, "dilutedRoe");
            return (Criteria) this;
        }

        public Criteria andDilutedRoeLessThan(Float value) {
            addCriterion("diluted_roe <", value, "dilutedRoe");
            return (Criteria) this;
        }

        public Criteria andDilutedRoeLessThanOrEqualTo(Float value) {
            addCriterion("diluted_roe <=", value, "dilutedRoe");
            return (Criteria) this;
        }

        public Criteria andDilutedRoeIn(List<Float> values) {
            addCriterion("diluted_roe in", values, "dilutedRoe");
            return (Criteria) this;
        }

        public Criteria andDilutedRoeNotIn(List<Float> values) {
            addCriterion("diluted_roe not in", values, "dilutedRoe");
            return (Criteria) this;
        }

        public Criteria andDilutedRoeBetween(Float value1, Float value2) {
            addCriterion("diluted_roe between", value1, value2, "dilutedRoe");
            return (Criteria) this;
        }

        public Criteria andDilutedRoeNotBetween(Float value1, Float value2) {
            addCriterion("diluted_roe not between", value1, value2, "dilutedRoe");
            return (Criteria) this;
        }

        public Criteria andYoyNetProfitIsNull() {
            addCriterion("yoy_net_profit is null");
            return (Criteria) this;
        }

        public Criteria andYoyNetProfitIsNotNull() {
            addCriterion("yoy_net_profit is not null");
            return (Criteria) this;
        }

        public Criteria andYoyNetProfitEqualTo(Float value) {
            addCriterion("yoy_net_profit =", value, "yoyNetProfit");
            return (Criteria) this;
        }

        public Criteria andYoyNetProfitNotEqualTo(Float value) {
            addCriterion("yoy_net_profit <>", value, "yoyNetProfit");
            return (Criteria) this;
        }

        public Criteria andYoyNetProfitGreaterThan(Float value) {
            addCriterion("yoy_net_profit >", value, "yoyNetProfit");
            return (Criteria) this;
        }

        public Criteria andYoyNetProfitGreaterThanOrEqualTo(Float value) {
            addCriterion("yoy_net_profit >=", value, "yoyNetProfit");
            return (Criteria) this;
        }

        public Criteria andYoyNetProfitLessThan(Float value) {
            addCriterion("yoy_net_profit <", value, "yoyNetProfit");
            return (Criteria) this;
        }

        public Criteria andYoyNetProfitLessThanOrEqualTo(Float value) {
            addCriterion("yoy_net_profit <=", value, "yoyNetProfit");
            return (Criteria) this;
        }

        public Criteria andYoyNetProfitIn(List<Float> values) {
            addCriterion("yoy_net_profit in", values, "yoyNetProfit");
            return (Criteria) this;
        }

        public Criteria andYoyNetProfitNotIn(List<Float> values) {
            addCriterion("yoy_net_profit not in", values, "yoyNetProfit");
            return (Criteria) this;
        }

        public Criteria andYoyNetProfitBetween(Float value1, Float value2) {
            addCriterion("yoy_net_profit between", value1, value2, "yoyNetProfit");
            return (Criteria) this;
        }

        public Criteria andYoyNetProfitNotBetween(Float value1, Float value2) {
            addCriterion("yoy_net_profit not between", value1, value2, "yoyNetProfit");
            return (Criteria) this;
        }

        public Criteria andBpsIsNull() {
            addCriterion("bps is null");
            return (Criteria) this;
        }

        public Criteria andBpsIsNotNull() {
            addCriterion("bps is not null");
            return (Criteria) this;
        }

        public Criteria andBpsEqualTo(Float value) {
            addCriterion("bps =", value, "bps");
            return (Criteria) this;
        }

        public Criteria andBpsNotEqualTo(Float value) {
            addCriterion("bps <>", value, "bps");
            return (Criteria) this;
        }

        public Criteria andBpsGreaterThan(Float value) {
            addCriterion("bps >", value, "bps");
            return (Criteria) this;
        }

        public Criteria andBpsGreaterThanOrEqualTo(Float value) {
            addCriterion("bps >=", value, "bps");
            return (Criteria) this;
        }

        public Criteria andBpsLessThan(Float value) {
            addCriterion("bps <", value, "bps");
            return (Criteria) this;
        }

        public Criteria andBpsLessThanOrEqualTo(Float value) {
            addCriterion("bps <=", value, "bps");
            return (Criteria) this;
        }

        public Criteria andBpsIn(List<Float> values) {
            addCriterion("bps in", values, "bps");
            return (Criteria) this;
        }

        public Criteria andBpsNotIn(List<Float> values) {
            addCriterion("bps not in", values, "bps");
            return (Criteria) this;
        }

        public Criteria andBpsBetween(Float value1, Float value2) {
            addCriterion("bps between", value1, value2, "bps");
            return (Criteria) this;
        }

        public Criteria andBpsNotBetween(Float value1, Float value2) {
            addCriterion("bps not between", value1, value2, "bps");
            return (Criteria) this;
        }

        public Criteria andYoySalesIsNull() {
            addCriterion("yoy_sales is null");
            return (Criteria) this;
        }

        public Criteria andYoySalesIsNotNull() {
            addCriterion("yoy_sales is not null");
            return (Criteria) this;
        }

        public Criteria andYoySalesEqualTo(Float value) {
            addCriterion("yoy_sales =", value, "yoySales");
            return (Criteria) this;
        }

        public Criteria andYoySalesNotEqualTo(Float value) {
            addCriterion("yoy_sales <>", value, "yoySales");
            return (Criteria) this;
        }

        public Criteria andYoySalesGreaterThan(Float value) {
            addCriterion("yoy_sales >", value, "yoySales");
            return (Criteria) this;
        }

        public Criteria andYoySalesGreaterThanOrEqualTo(Float value) {
            addCriterion("yoy_sales >=", value, "yoySales");
            return (Criteria) this;
        }

        public Criteria andYoySalesLessThan(Float value) {
            addCriterion("yoy_sales <", value, "yoySales");
            return (Criteria) this;
        }

        public Criteria andYoySalesLessThanOrEqualTo(Float value) {
            addCriterion("yoy_sales <=", value, "yoySales");
            return (Criteria) this;
        }

        public Criteria andYoySalesIn(List<Float> values) {
            addCriterion("yoy_sales in", values, "yoySales");
            return (Criteria) this;
        }

        public Criteria andYoySalesNotIn(List<Float> values) {
            addCriterion("yoy_sales not in", values, "yoySales");
            return (Criteria) this;
        }

        public Criteria andYoySalesBetween(Float value1, Float value2) {
            addCriterion("yoy_sales between", value1, value2, "yoySales");
            return (Criteria) this;
        }

        public Criteria andYoySalesNotBetween(Float value1, Float value2) {
            addCriterion("yoy_sales not between", value1, value2, "yoySales");
            return (Criteria) this;
        }

        public Criteria andYoyOpIsNull() {
            addCriterion("yoy_op is null");
            return (Criteria) this;
        }

        public Criteria andYoyOpIsNotNull() {
            addCriterion("yoy_op is not null");
            return (Criteria) this;
        }

        public Criteria andYoyOpEqualTo(Float value) {
            addCriterion("yoy_op =", value, "yoyOp");
            return (Criteria) this;
        }

        public Criteria andYoyOpNotEqualTo(Float value) {
            addCriterion("yoy_op <>", value, "yoyOp");
            return (Criteria) this;
        }

        public Criteria andYoyOpGreaterThan(Float value) {
            addCriterion("yoy_op >", value, "yoyOp");
            return (Criteria) this;
        }

        public Criteria andYoyOpGreaterThanOrEqualTo(Float value) {
            addCriterion("yoy_op >=", value, "yoyOp");
            return (Criteria) this;
        }

        public Criteria andYoyOpLessThan(Float value) {
            addCriterion("yoy_op <", value, "yoyOp");
            return (Criteria) this;
        }

        public Criteria andYoyOpLessThanOrEqualTo(Float value) {
            addCriterion("yoy_op <=", value, "yoyOp");
            return (Criteria) this;
        }

        public Criteria andYoyOpIn(List<Float> values) {
            addCriterion("yoy_op in", values, "yoyOp");
            return (Criteria) this;
        }

        public Criteria andYoyOpNotIn(List<Float> values) {
            addCriterion("yoy_op not in", values, "yoyOp");
            return (Criteria) this;
        }

        public Criteria andYoyOpBetween(Float value1, Float value2) {
            addCriterion("yoy_op between", value1, value2, "yoyOp");
            return (Criteria) this;
        }

        public Criteria andYoyOpNotBetween(Float value1, Float value2) {
            addCriterion("yoy_op not between", value1, value2, "yoyOp");
            return (Criteria) this;
        }

        public Criteria andYoyTpIsNull() {
            addCriterion("yoy_tp is null");
            return (Criteria) this;
        }

        public Criteria andYoyTpIsNotNull() {
            addCriterion("yoy_tp is not null");
            return (Criteria) this;
        }

        public Criteria andYoyTpEqualTo(Float value) {
            addCriterion("yoy_tp =", value, "yoyTp");
            return (Criteria) this;
        }

        public Criteria andYoyTpNotEqualTo(Float value) {
            addCriterion("yoy_tp <>", value, "yoyTp");
            return (Criteria) this;
        }

        public Criteria andYoyTpGreaterThan(Float value) {
            addCriterion("yoy_tp >", value, "yoyTp");
            return (Criteria) this;
        }

        public Criteria andYoyTpGreaterThanOrEqualTo(Float value) {
            addCriterion("yoy_tp >=", value, "yoyTp");
            return (Criteria) this;
        }

        public Criteria andYoyTpLessThan(Float value) {
            addCriterion("yoy_tp <", value, "yoyTp");
            return (Criteria) this;
        }

        public Criteria andYoyTpLessThanOrEqualTo(Float value) {
            addCriterion("yoy_tp <=", value, "yoyTp");
            return (Criteria) this;
        }

        public Criteria andYoyTpIn(List<Float> values) {
            addCriterion("yoy_tp in", values, "yoyTp");
            return (Criteria) this;
        }

        public Criteria andYoyTpNotIn(List<Float> values) {
            addCriterion("yoy_tp not in", values, "yoyTp");
            return (Criteria) this;
        }

        public Criteria andYoyTpBetween(Float value1, Float value2) {
            addCriterion("yoy_tp between", value1, value2, "yoyTp");
            return (Criteria) this;
        }

        public Criteria andYoyTpNotBetween(Float value1, Float value2) {
            addCriterion("yoy_tp not between", value1, value2, "yoyTp");
            return (Criteria) this;
        }

        public Criteria andYoyDeduNpIsNull() {
            addCriterion("yoy_dedu_np is null");
            return (Criteria) this;
        }

        public Criteria andYoyDeduNpIsNotNull() {
            addCriterion("yoy_dedu_np is not null");
            return (Criteria) this;
        }

        public Criteria andYoyDeduNpEqualTo(Float value) {
            addCriterion("yoy_dedu_np =", value, "yoyDeduNp");
            return (Criteria) this;
        }

        public Criteria andYoyDeduNpNotEqualTo(Float value) {
            addCriterion("yoy_dedu_np <>", value, "yoyDeduNp");
            return (Criteria) this;
        }

        public Criteria andYoyDeduNpGreaterThan(Float value) {
            addCriterion("yoy_dedu_np >", value, "yoyDeduNp");
            return (Criteria) this;
        }

        public Criteria andYoyDeduNpGreaterThanOrEqualTo(Float value) {
            addCriterion("yoy_dedu_np >=", value, "yoyDeduNp");
            return (Criteria) this;
        }

        public Criteria andYoyDeduNpLessThan(Float value) {
            addCriterion("yoy_dedu_np <", value, "yoyDeduNp");
            return (Criteria) this;
        }

        public Criteria andYoyDeduNpLessThanOrEqualTo(Float value) {
            addCriterion("yoy_dedu_np <=", value, "yoyDeduNp");
            return (Criteria) this;
        }

        public Criteria andYoyDeduNpIn(List<Float> values) {
            addCriterion("yoy_dedu_np in", values, "yoyDeduNp");
            return (Criteria) this;
        }

        public Criteria andYoyDeduNpNotIn(List<Float> values) {
            addCriterion("yoy_dedu_np not in", values, "yoyDeduNp");
            return (Criteria) this;
        }

        public Criteria andYoyDeduNpBetween(Float value1, Float value2) {
            addCriterion("yoy_dedu_np between", value1, value2, "yoyDeduNp");
            return (Criteria) this;
        }

        public Criteria andYoyDeduNpNotBetween(Float value1, Float value2) {
            addCriterion("yoy_dedu_np not between", value1, value2, "yoyDeduNp");
            return (Criteria) this;
        }

        public Criteria andYoyEpsIsNull() {
            addCriterion("yoy_eps is null");
            return (Criteria) this;
        }

        public Criteria andYoyEpsIsNotNull() {
            addCriterion("yoy_eps is not null");
            return (Criteria) this;
        }

        public Criteria andYoyEpsEqualTo(Float value) {
            addCriterion("yoy_eps =", value, "yoyEps");
            return (Criteria) this;
        }

        public Criteria andYoyEpsNotEqualTo(Float value) {
            addCriterion("yoy_eps <>", value, "yoyEps");
            return (Criteria) this;
        }

        public Criteria andYoyEpsGreaterThan(Float value) {
            addCriterion("yoy_eps >", value, "yoyEps");
            return (Criteria) this;
        }

        public Criteria andYoyEpsGreaterThanOrEqualTo(Float value) {
            addCriterion("yoy_eps >=", value, "yoyEps");
            return (Criteria) this;
        }

        public Criteria andYoyEpsLessThan(Float value) {
            addCriterion("yoy_eps <", value, "yoyEps");
            return (Criteria) this;
        }

        public Criteria andYoyEpsLessThanOrEqualTo(Float value) {
            addCriterion("yoy_eps <=", value, "yoyEps");
            return (Criteria) this;
        }

        public Criteria andYoyEpsIn(List<Float> values) {
            addCriterion("yoy_eps in", values, "yoyEps");
            return (Criteria) this;
        }

        public Criteria andYoyEpsNotIn(List<Float> values) {
            addCriterion("yoy_eps not in", values, "yoyEps");
            return (Criteria) this;
        }

        public Criteria andYoyEpsBetween(Float value1, Float value2) {
            addCriterion("yoy_eps between", value1, value2, "yoyEps");
            return (Criteria) this;
        }

        public Criteria andYoyEpsNotBetween(Float value1, Float value2) {
            addCriterion("yoy_eps not between", value1, value2, "yoyEps");
            return (Criteria) this;
        }

        public Criteria andYoyRoeIsNull() {
            addCriterion("yoy_roe is null");
            return (Criteria) this;
        }

        public Criteria andYoyRoeIsNotNull() {
            addCriterion("yoy_roe is not null");
            return (Criteria) this;
        }

        public Criteria andYoyRoeEqualTo(Float value) {
            addCriterion("yoy_roe =", value, "yoyRoe");
            return (Criteria) this;
        }

        public Criteria andYoyRoeNotEqualTo(Float value) {
            addCriterion("yoy_roe <>", value, "yoyRoe");
            return (Criteria) this;
        }

        public Criteria andYoyRoeGreaterThan(Float value) {
            addCriterion("yoy_roe >", value, "yoyRoe");
            return (Criteria) this;
        }

        public Criteria andYoyRoeGreaterThanOrEqualTo(Float value) {
            addCriterion("yoy_roe >=", value, "yoyRoe");
            return (Criteria) this;
        }

        public Criteria andYoyRoeLessThan(Float value) {
            addCriterion("yoy_roe <", value, "yoyRoe");
            return (Criteria) this;
        }

        public Criteria andYoyRoeLessThanOrEqualTo(Float value) {
            addCriterion("yoy_roe <=", value, "yoyRoe");
            return (Criteria) this;
        }

        public Criteria andYoyRoeIn(List<Float> values) {
            addCriterion("yoy_roe in", values, "yoyRoe");
            return (Criteria) this;
        }

        public Criteria andYoyRoeNotIn(List<Float> values) {
            addCriterion("yoy_roe not in", values, "yoyRoe");
            return (Criteria) this;
        }

        public Criteria andYoyRoeBetween(Float value1, Float value2) {
            addCriterion("yoy_roe between", value1, value2, "yoyRoe");
            return (Criteria) this;
        }

        public Criteria andYoyRoeNotBetween(Float value1, Float value2) {
            addCriterion("yoy_roe not between", value1, value2, "yoyRoe");
            return (Criteria) this;
        }

        public Criteria andGrowthAssetsIsNull() {
            addCriterion("growth_assets is null");
            return (Criteria) this;
        }

        public Criteria andGrowthAssetsIsNotNull() {
            addCriterion("growth_assets is not null");
            return (Criteria) this;
        }

        public Criteria andGrowthAssetsEqualTo(Float value) {
            addCriterion("growth_assets =", value, "growthAssets");
            return (Criteria) this;
        }

        public Criteria andGrowthAssetsNotEqualTo(Float value) {
            addCriterion("growth_assets <>", value, "growthAssets");
            return (Criteria) this;
        }

        public Criteria andGrowthAssetsGreaterThan(Float value) {
            addCriterion("growth_assets >", value, "growthAssets");
            return (Criteria) this;
        }

        public Criteria andGrowthAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("growth_assets >=", value, "growthAssets");
            return (Criteria) this;
        }

        public Criteria andGrowthAssetsLessThan(Float value) {
            addCriterion("growth_assets <", value, "growthAssets");
            return (Criteria) this;
        }

        public Criteria andGrowthAssetsLessThanOrEqualTo(Float value) {
            addCriterion("growth_assets <=", value, "growthAssets");
            return (Criteria) this;
        }

        public Criteria andGrowthAssetsIn(List<Float> values) {
            addCriterion("growth_assets in", values, "growthAssets");
            return (Criteria) this;
        }

        public Criteria andGrowthAssetsNotIn(List<Float> values) {
            addCriterion("growth_assets not in", values, "growthAssets");
            return (Criteria) this;
        }

        public Criteria andGrowthAssetsBetween(Float value1, Float value2) {
            addCriterion("growth_assets between", value1, value2, "growthAssets");
            return (Criteria) this;
        }

        public Criteria andGrowthAssetsNotBetween(Float value1, Float value2) {
            addCriterion("growth_assets not between", value1, value2, "growthAssets");
            return (Criteria) this;
        }

        public Criteria andYoyEquityIsNull() {
            addCriterion("yoy_equity is null");
            return (Criteria) this;
        }

        public Criteria andYoyEquityIsNotNull() {
            addCriterion("yoy_equity is not null");
            return (Criteria) this;
        }

        public Criteria andYoyEquityEqualTo(Float value) {
            addCriterion("yoy_equity =", value, "yoyEquity");
            return (Criteria) this;
        }

        public Criteria andYoyEquityNotEqualTo(Float value) {
            addCriterion("yoy_equity <>", value, "yoyEquity");
            return (Criteria) this;
        }

        public Criteria andYoyEquityGreaterThan(Float value) {
            addCriterion("yoy_equity >", value, "yoyEquity");
            return (Criteria) this;
        }

        public Criteria andYoyEquityGreaterThanOrEqualTo(Float value) {
            addCriterion("yoy_equity >=", value, "yoyEquity");
            return (Criteria) this;
        }

        public Criteria andYoyEquityLessThan(Float value) {
            addCriterion("yoy_equity <", value, "yoyEquity");
            return (Criteria) this;
        }

        public Criteria andYoyEquityLessThanOrEqualTo(Float value) {
            addCriterion("yoy_equity <=", value, "yoyEquity");
            return (Criteria) this;
        }

        public Criteria andYoyEquityIn(List<Float> values) {
            addCriterion("yoy_equity in", values, "yoyEquity");
            return (Criteria) this;
        }

        public Criteria andYoyEquityNotIn(List<Float> values) {
            addCriterion("yoy_equity not in", values, "yoyEquity");
            return (Criteria) this;
        }

        public Criteria andYoyEquityBetween(Float value1, Float value2) {
            addCriterion("yoy_equity between", value1, value2, "yoyEquity");
            return (Criteria) this;
        }

        public Criteria andYoyEquityNotBetween(Float value1, Float value2) {
            addCriterion("yoy_equity not between", value1, value2, "yoyEquity");
            return (Criteria) this;
        }

        public Criteria andGrowthBpsIsNull() {
            addCriterion("growth_bps is null");
            return (Criteria) this;
        }

        public Criteria andGrowthBpsIsNotNull() {
            addCriterion("growth_bps is not null");
            return (Criteria) this;
        }

        public Criteria andGrowthBpsEqualTo(Float value) {
            addCriterion("growth_bps =", value, "growthBps");
            return (Criteria) this;
        }

        public Criteria andGrowthBpsNotEqualTo(Float value) {
            addCriterion("growth_bps <>", value, "growthBps");
            return (Criteria) this;
        }

        public Criteria andGrowthBpsGreaterThan(Float value) {
            addCriterion("growth_bps >", value, "growthBps");
            return (Criteria) this;
        }

        public Criteria andGrowthBpsGreaterThanOrEqualTo(Float value) {
            addCriterion("growth_bps >=", value, "growthBps");
            return (Criteria) this;
        }

        public Criteria andGrowthBpsLessThan(Float value) {
            addCriterion("growth_bps <", value, "growthBps");
            return (Criteria) this;
        }

        public Criteria andGrowthBpsLessThanOrEqualTo(Float value) {
            addCriterion("growth_bps <=", value, "growthBps");
            return (Criteria) this;
        }

        public Criteria andGrowthBpsIn(List<Float> values) {
            addCriterion("growth_bps in", values, "growthBps");
            return (Criteria) this;
        }

        public Criteria andGrowthBpsNotIn(List<Float> values) {
            addCriterion("growth_bps not in", values, "growthBps");
            return (Criteria) this;
        }

        public Criteria andGrowthBpsBetween(Float value1, Float value2) {
            addCriterion("growth_bps between", value1, value2, "growthBps");
            return (Criteria) this;
        }

        public Criteria andGrowthBpsNotBetween(Float value1, Float value2) {
            addCriterion("growth_bps not between", value1, value2, "growthBps");
            return (Criteria) this;
        }

        public Criteria andOrLastYearIsNull() {
            addCriterion("or_last_year is null");
            return (Criteria) this;
        }

        public Criteria andOrLastYearIsNotNull() {
            addCriterion("or_last_year is not null");
            return (Criteria) this;
        }

        public Criteria andOrLastYearEqualTo(Float value) {
            addCriterion("or_last_year =", value, "orLastYear");
            return (Criteria) this;
        }

        public Criteria andOrLastYearNotEqualTo(Float value) {
            addCriterion("or_last_year <>", value, "orLastYear");
            return (Criteria) this;
        }

        public Criteria andOrLastYearGreaterThan(Float value) {
            addCriterion("or_last_year >", value, "orLastYear");
            return (Criteria) this;
        }

        public Criteria andOrLastYearGreaterThanOrEqualTo(Float value) {
            addCriterion("or_last_year >=", value, "orLastYear");
            return (Criteria) this;
        }

        public Criteria andOrLastYearLessThan(Float value) {
            addCriterion("or_last_year <", value, "orLastYear");
            return (Criteria) this;
        }

        public Criteria andOrLastYearLessThanOrEqualTo(Float value) {
            addCriterion("or_last_year <=", value, "orLastYear");
            return (Criteria) this;
        }

        public Criteria andOrLastYearIn(List<Float> values) {
            addCriterion("or_last_year in", values, "orLastYear");
            return (Criteria) this;
        }

        public Criteria andOrLastYearNotIn(List<Float> values) {
            addCriterion("or_last_year not in", values, "orLastYear");
            return (Criteria) this;
        }

        public Criteria andOrLastYearBetween(Float value1, Float value2) {
            addCriterion("or_last_year between", value1, value2, "orLastYear");
            return (Criteria) this;
        }

        public Criteria andOrLastYearNotBetween(Float value1, Float value2) {
            addCriterion("or_last_year not between", value1, value2, "orLastYear");
            return (Criteria) this;
        }

        public Criteria andOpLastYearIsNull() {
            addCriterion("op_last_year is null");
            return (Criteria) this;
        }

        public Criteria andOpLastYearIsNotNull() {
            addCriterion("op_last_year is not null");
            return (Criteria) this;
        }

        public Criteria andOpLastYearEqualTo(Float value) {
            addCriterion("op_last_year =", value, "opLastYear");
            return (Criteria) this;
        }

        public Criteria andOpLastYearNotEqualTo(Float value) {
            addCriterion("op_last_year <>", value, "opLastYear");
            return (Criteria) this;
        }

        public Criteria andOpLastYearGreaterThan(Float value) {
            addCriterion("op_last_year >", value, "opLastYear");
            return (Criteria) this;
        }

        public Criteria andOpLastYearGreaterThanOrEqualTo(Float value) {
            addCriterion("op_last_year >=", value, "opLastYear");
            return (Criteria) this;
        }

        public Criteria andOpLastYearLessThan(Float value) {
            addCriterion("op_last_year <", value, "opLastYear");
            return (Criteria) this;
        }

        public Criteria andOpLastYearLessThanOrEqualTo(Float value) {
            addCriterion("op_last_year <=", value, "opLastYear");
            return (Criteria) this;
        }

        public Criteria andOpLastYearIn(List<Float> values) {
            addCriterion("op_last_year in", values, "opLastYear");
            return (Criteria) this;
        }

        public Criteria andOpLastYearNotIn(List<Float> values) {
            addCriterion("op_last_year not in", values, "opLastYear");
            return (Criteria) this;
        }

        public Criteria andOpLastYearBetween(Float value1, Float value2) {
            addCriterion("op_last_year between", value1, value2, "opLastYear");
            return (Criteria) this;
        }

        public Criteria andOpLastYearNotBetween(Float value1, Float value2) {
            addCriterion("op_last_year not between", value1, value2, "opLastYear");
            return (Criteria) this;
        }

        public Criteria andTpLastYearIsNull() {
            addCriterion("tp_last_year is null");
            return (Criteria) this;
        }

        public Criteria andTpLastYearIsNotNull() {
            addCriterion("tp_last_year is not null");
            return (Criteria) this;
        }

        public Criteria andTpLastYearEqualTo(Float value) {
            addCriterion("tp_last_year =", value, "tpLastYear");
            return (Criteria) this;
        }

        public Criteria andTpLastYearNotEqualTo(Float value) {
            addCriterion("tp_last_year <>", value, "tpLastYear");
            return (Criteria) this;
        }

        public Criteria andTpLastYearGreaterThan(Float value) {
            addCriterion("tp_last_year >", value, "tpLastYear");
            return (Criteria) this;
        }

        public Criteria andTpLastYearGreaterThanOrEqualTo(Float value) {
            addCriterion("tp_last_year >=", value, "tpLastYear");
            return (Criteria) this;
        }

        public Criteria andTpLastYearLessThan(Float value) {
            addCriterion("tp_last_year <", value, "tpLastYear");
            return (Criteria) this;
        }

        public Criteria andTpLastYearLessThanOrEqualTo(Float value) {
            addCriterion("tp_last_year <=", value, "tpLastYear");
            return (Criteria) this;
        }

        public Criteria andTpLastYearIn(List<Float> values) {
            addCriterion("tp_last_year in", values, "tpLastYear");
            return (Criteria) this;
        }

        public Criteria andTpLastYearNotIn(List<Float> values) {
            addCriterion("tp_last_year not in", values, "tpLastYear");
            return (Criteria) this;
        }

        public Criteria andTpLastYearBetween(Float value1, Float value2) {
            addCriterion("tp_last_year between", value1, value2, "tpLastYear");
            return (Criteria) this;
        }

        public Criteria andTpLastYearNotBetween(Float value1, Float value2) {
            addCriterion("tp_last_year not between", value1, value2, "tpLastYear");
            return (Criteria) this;
        }

        public Criteria andNpLastYearIsNull() {
            addCriterion("np_last_year is null");
            return (Criteria) this;
        }

        public Criteria andNpLastYearIsNotNull() {
            addCriterion("np_last_year is not null");
            return (Criteria) this;
        }

        public Criteria andNpLastYearEqualTo(Float value) {
            addCriterion("np_last_year =", value, "npLastYear");
            return (Criteria) this;
        }

        public Criteria andNpLastYearNotEqualTo(Float value) {
            addCriterion("np_last_year <>", value, "npLastYear");
            return (Criteria) this;
        }

        public Criteria andNpLastYearGreaterThan(Float value) {
            addCriterion("np_last_year >", value, "npLastYear");
            return (Criteria) this;
        }

        public Criteria andNpLastYearGreaterThanOrEqualTo(Float value) {
            addCriterion("np_last_year >=", value, "npLastYear");
            return (Criteria) this;
        }

        public Criteria andNpLastYearLessThan(Float value) {
            addCriterion("np_last_year <", value, "npLastYear");
            return (Criteria) this;
        }

        public Criteria andNpLastYearLessThanOrEqualTo(Float value) {
            addCriterion("np_last_year <=", value, "npLastYear");
            return (Criteria) this;
        }

        public Criteria andNpLastYearIn(List<Float> values) {
            addCriterion("np_last_year in", values, "npLastYear");
            return (Criteria) this;
        }

        public Criteria andNpLastYearNotIn(List<Float> values) {
            addCriterion("np_last_year not in", values, "npLastYear");
            return (Criteria) this;
        }

        public Criteria andNpLastYearBetween(Float value1, Float value2) {
            addCriterion("np_last_year between", value1, value2, "npLastYear");
            return (Criteria) this;
        }

        public Criteria andNpLastYearNotBetween(Float value1, Float value2) {
            addCriterion("np_last_year not between", value1, value2, "npLastYear");
            return (Criteria) this;
        }

        public Criteria andEpsLastYearIsNull() {
            addCriterion("eps_last_year is null");
            return (Criteria) this;
        }

        public Criteria andEpsLastYearIsNotNull() {
            addCriterion("eps_last_year is not null");
            return (Criteria) this;
        }

        public Criteria andEpsLastYearEqualTo(Float value) {
            addCriterion("eps_last_year =", value, "epsLastYear");
            return (Criteria) this;
        }

        public Criteria andEpsLastYearNotEqualTo(Float value) {
            addCriterion("eps_last_year <>", value, "epsLastYear");
            return (Criteria) this;
        }

        public Criteria andEpsLastYearGreaterThan(Float value) {
            addCriterion("eps_last_year >", value, "epsLastYear");
            return (Criteria) this;
        }

        public Criteria andEpsLastYearGreaterThanOrEqualTo(Float value) {
            addCriterion("eps_last_year >=", value, "epsLastYear");
            return (Criteria) this;
        }

        public Criteria andEpsLastYearLessThan(Float value) {
            addCriterion("eps_last_year <", value, "epsLastYear");
            return (Criteria) this;
        }

        public Criteria andEpsLastYearLessThanOrEqualTo(Float value) {
            addCriterion("eps_last_year <=", value, "epsLastYear");
            return (Criteria) this;
        }

        public Criteria andEpsLastYearIn(List<Float> values) {
            addCriterion("eps_last_year in", values, "epsLastYear");
            return (Criteria) this;
        }

        public Criteria andEpsLastYearNotIn(List<Float> values) {
            addCriterion("eps_last_year not in", values, "epsLastYear");
            return (Criteria) this;
        }

        public Criteria andEpsLastYearBetween(Float value1, Float value2) {
            addCriterion("eps_last_year between", value1, value2, "epsLastYear");
            return (Criteria) this;
        }

        public Criteria andEpsLastYearNotBetween(Float value1, Float value2) {
            addCriterion("eps_last_year not between", value1, value2, "epsLastYear");
            return (Criteria) this;
        }

        public Criteria andOpenNetAssetsIsNull() {
            addCriterion("open_net_assets is null");
            return (Criteria) this;
        }

        public Criteria andOpenNetAssetsIsNotNull() {
            addCriterion("open_net_assets is not null");
            return (Criteria) this;
        }

        public Criteria andOpenNetAssetsEqualTo(Float value) {
            addCriterion("open_net_assets =", value, "openNetAssets");
            return (Criteria) this;
        }

        public Criteria andOpenNetAssetsNotEqualTo(Float value) {
            addCriterion("open_net_assets <>", value, "openNetAssets");
            return (Criteria) this;
        }

        public Criteria andOpenNetAssetsGreaterThan(Float value) {
            addCriterion("open_net_assets >", value, "openNetAssets");
            return (Criteria) this;
        }

        public Criteria andOpenNetAssetsGreaterThanOrEqualTo(Float value) {
            addCriterion("open_net_assets >=", value, "openNetAssets");
            return (Criteria) this;
        }

        public Criteria andOpenNetAssetsLessThan(Float value) {
            addCriterion("open_net_assets <", value, "openNetAssets");
            return (Criteria) this;
        }

        public Criteria andOpenNetAssetsLessThanOrEqualTo(Float value) {
            addCriterion("open_net_assets <=", value, "openNetAssets");
            return (Criteria) this;
        }

        public Criteria andOpenNetAssetsIn(List<Float> values) {
            addCriterion("open_net_assets in", values, "openNetAssets");
            return (Criteria) this;
        }

        public Criteria andOpenNetAssetsNotIn(List<Float> values) {
            addCriterion("open_net_assets not in", values, "openNetAssets");
            return (Criteria) this;
        }

        public Criteria andOpenNetAssetsBetween(Float value1, Float value2) {
            addCriterion("open_net_assets between", value1, value2, "openNetAssets");
            return (Criteria) this;
        }

        public Criteria andOpenNetAssetsNotBetween(Float value1, Float value2) {
            addCriterion("open_net_assets not between", value1, value2, "openNetAssets");
            return (Criteria) this;
        }

        public Criteria andOpenBpsIsNull() {
            addCriterion("open_bps is null");
            return (Criteria) this;
        }

        public Criteria andOpenBpsIsNotNull() {
            addCriterion("open_bps is not null");
            return (Criteria) this;
        }

        public Criteria andOpenBpsEqualTo(Float value) {
            addCriterion("open_bps =", value, "openBps");
            return (Criteria) this;
        }

        public Criteria andOpenBpsNotEqualTo(Float value) {
            addCriterion("open_bps <>", value, "openBps");
            return (Criteria) this;
        }

        public Criteria andOpenBpsGreaterThan(Float value) {
            addCriterion("open_bps >", value, "openBps");
            return (Criteria) this;
        }

        public Criteria andOpenBpsGreaterThanOrEqualTo(Float value) {
            addCriterion("open_bps >=", value, "openBps");
            return (Criteria) this;
        }

        public Criteria andOpenBpsLessThan(Float value) {
            addCriterion("open_bps <", value, "openBps");
            return (Criteria) this;
        }

        public Criteria andOpenBpsLessThanOrEqualTo(Float value) {
            addCriterion("open_bps <=", value, "openBps");
            return (Criteria) this;
        }

        public Criteria andOpenBpsIn(List<Float> values) {
            addCriterion("open_bps in", values, "openBps");
            return (Criteria) this;
        }

        public Criteria andOpenBpsNotIn(List<Float> values) {
            addCriterion("open_bps not in", values, "openBps");
            return (Criteria) this;
        }

        public Criteria andOpenBpsBetween(Float value1, Float value2) {
            addCriterion("open_bps between", value1, value2, "openBps");
            return (Criteria) this;
        }

        public Criteria andOpenBpsNotBetween(Float value1, Float value2) {
            addCriterion("open_bps not between", value1, value2, "openBps");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryIsNull() {
            addCriterion("perf_summary is null");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryIsNotNull() {
            addCriterion("perf_summary is not null");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryEqualTo(String value) {
            addCriterion("perf_summary =", value, "perfSummary");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryNotEqualTo(String value) {
            addCriterion("perf_summary <>", value, "perfSummary");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryGreaterThan(String value) {
            addCriterion("perf_summary >", value, "perfSummary");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryGreaterThanOrEqualTo(String value) {
            addCriterion("perf_summary >=", value, "perfSummary");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryLessThan(String value) {
            addCriterion("perf_summary <", value, "perfSummary");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryLessThanOrEqualTo(String value) {
            addCriterion("perf_summary <=", value, "perfSummary");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryLike(String value) {
            addCriterion("perf_summary like", value, "perfSummary");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryNotLike(String value) {
            addCriterion("perf_summary not like", value, "perfSummary");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryIn(List<String> values) {
            addCriterion("perf_summary in", values, "perfSummary");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryNotIn(List<String> values) {
            addCriterion("perf_summary not in", values, "perfSummary");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryBetween(String value1, String value2) {
            addCriterion("perf_summary between", value1, value2, "perfSummary");
            return (Criteria) this;
        }

        public Criteria andPerfSummaryNotBetween(String value1, String value2) {
            addCriterion("perf_summary not between", value1, value2, "perfSummary");
            return (Criteria) this;
        }

        public Criteria andIsAuditIsNull() {
            addCriterion("is_audit is null");
            return (Criteria) this;
        }

        public Criteria andIsAuditIsNotNull() {
            addCriterion("is_audit is not null");
            return (Criteria) this;
        }

        public Criteria andIsAuditEqualTo(Integer value) {
            addCriterion("is_audit =", value, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditNotEqualTo(Integer value) {
            addCriterion("is_audit <>", value, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditGreaterThan(Integer value) {
            addCriterion("is_audit >", value, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditGreaterThanOrEqualTo(Integer value) {
            addCriterion("is_audit >=", value, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditLessThan(Integer value) {
            addCriterion("is_audit <", value, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditLessThanOrEqualTo(Integer value) {
            addCriterion("is_audit <=", value, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditIn(List<Integer> values) {
            addCriterion("is_audit in", values, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditNotIn(List<Integer> values) {
            addCriterion("is_audit not in", values, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditBetween(Integer value1, Integer value2) {
            addCriterion("is_audit between", value1, value2, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditNotBetween(Integer value1, Integer value2) {
            addCriterion("is_audit not between", value1, value2, "isAudit");
            return (Criteria) this;
        }

        public Criteria andRemarkIsNull() {
            addCriterion("remark is null");
            return (Criteria) this;
        }

        public Criteria andRemarkIsNotNull() {
            addCriterion("remark is not null");
            return (Criteria) this;
        }

        public Criteria andRemarkEqualTo(String value) {
            addCriterion("remark =", value, "remark");
            return (Criteria) this;
        }

        public Criteria andRemarkNotEqualTo(String value) {
            addCriterion("remark <>", value, "remark");
            return (Criteria) this;
        }

        public Criteria andRemarkGreaterThan(String value) {
            addCriterion("remark >", value, "remark");
            return (Criteria) this;
        }

        public Criteria andRemarkGreaterThanOrEqualTo(String value) {
            addCriterion("remark >=", value, "remark");
            return (Criteria) this;
        }

        public Criteria andRemarkLessThan(String value) {
            addCriterion("remark <", value, "remark");
            return (Criteria) this;
        }

        public Criteria andRemarkLessThanOrEqualTo(String value) {
            addCriterion("remark <=", value, "remark");
            return (Criteria) this;
        }

        public Criteria andRemarkLike(String value) {
            addCriterion("remark like", value, "remark");
            return (Criteria) this;
        }

        public Criteria andRemarkNotLike(String value) {
            addCriterion("remark not like", value, "remark");
            return (Criteria) this;
        }

        public Criteria andRemarkIn(List<String> values) {
            addCriterion("remark in", values, "remark");
            return (Criteria) this;
        }

        public Criteria andRemarkNotIn(List<String> values) {
            addCriterion("remark not in", values, "remark");
            return (Criteria) this;
        }

        public Criteria andRemarkBetween(String value1, String value2) {
            addCriterion("remark between", value1, value2, "remark");
            return (Criteria) this;
        }

        public Criteria andRemarkNotBetween(String value1, String value2) {
            addCriterion("remark not between", value1, value2, "remark");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}